import type { BaseResponse } from "@/types/api";
import axios, { type AxiosInstance, type AxiosRequestConfig, type AxiosResponse, AxiosError } from "axios";
import { useAuthStore } from "@/stores/auth";
import router from "@/router";
import { ElMessage } from "element-plus";

const { VITE_API_BASE_PREFIX, VITE_API_BASE_VARSION } = import.meta.env;

// 创建axios实例
const http: AxiosInstance = axios.create({
  baseURL: `/${VITE_API_BASE_PREFIX}/${VITE_API_BASE_VARSION}`,
  timeout: 10000,
  headers: {
    "Content-Type": "application/json",
  },
});

// 401 处理标志位，防止重复处理
let isHandling401 = false;
let handling401Promise: Promise<void> | null = null;

// 请求拦截器
http.interceptors.request.use(
  (config) => {
    // 如果正在处理 401，且当前路径不是登录页，则取消请求
    if (isHandling401 && router.currentRoute.value.path !== "/login") {
      // 取消请求
      const cancelToken = axios.CancelToken.source();
      config.cancelToken = cancelToken.token;
      cancelToken.cancel("正在处理登录过期，取消请求");
    }

    // 从 localStorage 获取 token（由 pinia-plugin-persistedstate 自动管理）
    const authStore = localStorage.getItem("auth-store");
    if (authStore) {
      try {
        const parsedStore = JSON.parse(authStore);
        const token = parsedStore.token;
        if (token) {
          config.headers.Authorization = `Bearer ${token}`;
        }
      } catch (error) {
        console.warn("解析认证信息失败:", error);
      }
    }

    // 打印请求信息（开发环境）
    if (import.meta.env.DEV) {
      console.log("🚀 Request:", {
        method: config.method?.toUpperCase(),
        url: config.url,
        data: config.data,
        params: config.params,
      });
    }

    return config;
  },
  (error) => {
    console.error("❌ Request Error:", error);
    return Promise.reject(error);
  },
);

// 响应拦截器
http.interceptors.response.use(
  (response: AxiosResponse) => {
    // 打印响应信息（开发环境）
    if (import.meta.env.DEV) {
      console.log("✅ Response:", {
        status: response.status,
        url: response.config.url,
        data: response.data,
      });
    }

    return response.data;
  },
  async (error: AxiosError) => {
    console.error("❌ Response Error:", error);

    // 处理常见的HTTP错误
    if (error.response) {
      const { status, data } = error.response;
      // 定义错误数据的类型，支持 message 属性
      const errorData = data as { message?: string } | string | null | undefined;

      switch (status) {
        case 401:
          // 如果正在处理 401 或已在登录页，直接拒绝
          if (isHandling401 || router.currentRoute.value.path === "/login") {
            return Promise.reject(new Error("登录已过期，请重新登录"));
          }

          // 设置标志位，防止重复处理
          if (!handling401Promise) {
            isHandling401 = true;
            handling401Promise = (async () => {
              try {
                const authStore = useAuthStore();
                // 清除认证信息
                await authStore.clearAuth();

                // 只在非登录页时显示消息和跳转
                if (router.currentRoute.value.path !== "/login") {
                  ElMessage.warning("登录已过期，请重新登录");
                  await router.replace({ name: "Login" });
                }
              } catch (err) {
                console.error("处理 401 错误时出错:", err);
              } finally {
                // 延迟重置标志位，确保所有并发请求都能被正确处理
                setTimeout(() => {
                  isHandling401 = false;
                  handling401Promise = null;
                }, 1000);
              }
            })();
          }

          // 等待 401 处理完成
          await handling401Promise;
          return Promise.reject(new Error("登录已过期，请重新登录"));

        case 403:
          console.error("权限不足");
          return Promise.reject(new Error((typeof errorData === "object" && errorData?.message) || "权限不足"));

        case 404:
          console.error("请求的资源不存在");
          return Promise.reject(new Error((typeof errorData === "object" && errorData?.message) || "请求的资源不存在"));

        case 500:
          console.error("服务器内部错误");
          return Promise.reject(new Error((typeof errorData === "object" && errorData?.message) || "服务器内部错误"));

        default:
          console.error(`请求失败: ${status}`);
          return Promise.reject(
            new Error((typeof errorData === "object" && errorData?.message) || `HTTP Error: ${status}`),
          );
      }
    } else if (error.request) {
      // 网络错误
      console.error("网络连接失败");
      return Promise.reject(new Error("网络连接失败，请检查网络设置"));
    } else {
      // 其他错误（包括取消的请求）
      if (axios.isCancel(error)) {
        return Promise.reject(new Error("请求已取消"));
      }
      return Promise.reject(error);
    }
  },
);

// 通用请求方法
export const request = <T = BaseResponse>(config: AxiosRequestConfig): Promise<T> => {
  return http(config);
};

// GET请求
export const get = <T = BaseResponse>(url: string, params?: any): Promise<T> => {
  return http.get(url, { params });
};

// POST请求
export const post = <T = BaseResponse>(url: string, data?: any): Promise<T> => {
  return http.post(url, data);
};

// PUT请求
export const put = <T = BaseResponse>(url: string, data?: any): Promise<T> => {
  return http.put(url, data);
};

// DELETE请求
export const del = <T = BaseResponse>(url: string): Promise<T> => {
  return http.delete(url);
};

// PATCH请求
export const patch = <T = BaseResponse>(url: string, data?: any): Promise<T> => {
  return http.patch(url, data);
};

export default http;
